{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Reinforcement Learning <em> in Action  </em>\n",
    "## Ch 3 - Deep Q-Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from Gridworld import *\n",
    "from IPython.display import clear_output\n",
    "import random\n",
    "from matplotlib import pylab as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def running_mean(x, N=500):\n",
    "    cumsum = np.cumsum(np.insert(x, 0, 0)) \n",
    "    return (cumsum[N:] - cumsum[:-N]) / float(N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testModel(model, mode='static', display=True):\n",
    "    epsilon = 0.05\n",
    "    max_moves = 50\n",
    "    win = False\n",
    "    i = 0\n",
    "    test_game = Gridworld(mode=mode)\n",
    "    state_ = test_game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "    state = Variable(torch.from_numpy(state_).float())\n",
    "    if display: \n",
    "        print(\"Initial State:\")\n",
    "        print(test_game.display())\n",
    "    status = 1\n",
    "    #while game still in progress\n",
    "    while(status == 1):\n",
    "        qval = model(state)\n",
    "        qval_ = qval.data.numpy()\n",
    "        if (random.random() < epsilon):\n",
    "            action_ = np.random.randint(0,4)\n",
    "        else:\n",
    "            action_ = np.argmax(qval_)\n",
    "        #action_ = np.argmax(qval_) #take action with highest Q-value\n",
    "        action = action_set[action_]\n",
    "        if display: print('Move #: %s; Taking action: %s' % (i, action))\n",
    "        test_game.makeMove(action)\n",
    "        state_ = test_game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "        state = Variable(torch.from_numpy(state_).float())\n",
    "        if display: print(test_game.display())\n",
    "        reward = test_game.reward()\n",
    "        if reward == 10:\n",
    "            status = 0\n",
    "            win = True\n",
    "            if display: print(\"You won! Reward: {}\".format(reward,))\n",
    "        elif reward == -10:\n",
    "            status = 0\n",
    "            if display: print(\"Game lost; stepped into the pit. Penalty: {}\".format(reward,))\n",
    "        i += 1 #If we're taking more than 10 actions, just stop, we probably can't win this game\n",
    "        if (i > max_moves):\n",
    "            if display: print(\"Game lost; too many moves.\")\n",
    "            break\n",
    "    return win"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_win_perc(model, max_games=1000):\n",
    "    wins = 0\n",
    "    for i in range(max_games):\n",
    "        win = testModel(model, 'random', display=False)\n",
    "        if win:\n",
    "            wins += 1\n",
    "    win_perc = float(wins) / float(max_games)\n",
    "    print(\"Games played: {0}, # of wins: {1}\".format(max_games,wins))\n",
    "    print(\"Win percentage: {}\".format(win_perc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = 64\n",
    "l2 = 164\n",
    "l3 = 150\n",
    "l4 = 4\n",
    "\n",
    "model = torch.nn.Sequential(\n",
    "    torch.nn.Linear(l1, l2),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l2, l3),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l3,l4)\n",
    ")\n",
    "\n",
    "loss_fn = torch.nn.MSELoss(size_average=False)\n",
    "\n",
    "learning_rate = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "\n",
    "#reinforcement learning specific parameters\n",
    "gamma = 0.9 #since it may take several moves to goal, making gamma high\n",
    "epsilon = 1.0\n",
    "\n",
    "action_set = {\n",
    "    0: 'u',\n",
    "    1: 'd',\n",
    "    2: 'l',\n",
    "    3: 'r',\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Without experience replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 0.029870163649320602\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-448853d32d49>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     33\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m         \u001b[0mlosses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/deeprl/lib/python3.6/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m     91\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     92\u001b[0m         \"\"\"\n\u001b[0;32m---> 93\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/deeprl/lib/python3.6/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     87\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     88\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 89\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     90\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "epochs = 1000\n",
    "losses = []\n",
    "for i in range(epochs):\n",
    "    game = Gridworld(size=4, mode='static')\n",
    "    state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "    state = Variable(torch.from_numpy(state_).float())\n",
    "    status = 1\n",
    "    #while game still in progress\n",
    "    while(status == 1):\n",
    "        qval = model(state)\n",
    "        qval_ = qval.data.numpy()\n",
    "        if (random.random() < epsilon):\n",
    "            action_ = np.random.randint(0,4)\n",
    "        else:\n",
    "            action_ = (np.argmax(qval_))\n",
    "        \n",
    "        action = action_set[action_]\n",
    "        game.makeMove(action)\n",
    "        new_state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "        new_state = Variable(torch.from_numpy(new_state_).float())\n",
    "        reward = game.reward()\n",
    "        newQ = model(new_state.reshape(1,64)).data.numpy()\n",
    "        maxQ = np.max(newQ)\n",
    "        y = np.zeros((1,4))\n",
    "        y[:] = qval_[:]\n",
    "        if reward == -1:\n",
    "            update = (reward + (gamma * maxQ))\n",
    "        else:\n",
    "            update = reward\n",
    "        y[0][action_] = update\n",
    "        y = Variable(torch.from_numpy(y).float())\n",
    "        loss = loss_fn(qval, y)\n",
    "        print(i, loss.item())\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        losses.append(loss.data[0])\n",
    "        optimizer.step()\n",
    "        state = new_state\n",
    "        if reward != -1:\n",
    "            status = 0\n",
    "        clear_output(wait=True)\n",
    "    if epsilon > 0.1:\n",
    "        epsilon -= (1/epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.xlabel(\"Training Steps\")\n",
    "plt.plot(losses)\n",
    "plt.savefig(\"dqn_1_loss_plot.pdf\", format=\"pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testModel(model, 'random')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = 64\n",
    "l2 = 200\n",
    "l3 = 150\n",
    "l4 = 100\n",
    "l5 = 4\n",
    "\n",
    "model2 = torch.nn.Sequential(\n",
    "    torch.nn.Linear(l1, l2),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l2, l3),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l3,l4),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l4,l5)\n",
    ")\n",
    "\n",
    "loss_fn2 = torch.nn.MSELoss(size_average=False)\n",
    "\n",
    "learning_rate2 = 1e-4\n",
    "optimizer2 = torch.optim.Adam(model2.parameters(), lr=learning_rate2)\n",
    "\n",
    "\n",
    "#reinforcement learning specific parameters\n",
    "gamma = 0.9 #since it may take several moves to goal, making gamma high\n",
    "epsilon = 1.0\n",
    "\n",
    "action_set = {\n",
    "    0: 'u',\n",
    "    1: 'd',\n",
    "    2: 'l',\n",
    "    3: 'r',\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With experience replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 1500\n",
    "losses = []\n",
    "batchSize = 40\n",
    "buffer = 80\n",
    "replay = []\n",
    "max_moves = 75\n",
    "h = 0\n",
    "for i in range(epochs):\n",
    "    game = Gridworld(size=4, mode='random')\n",
    "    state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "    state = Variable(torch.from_numpy(state_).float())\n",
    "    status = 1\n",
    "    mov = 0\n",
    "    #while game still in progress\n",
    "    while(status == 1):\n",
    "        mov += 1\n",
    "        qval = model2(state)\n",
    "        qval_ = qval.data.numpy()\n",
    "        if (random.random() < epsilon):\n",
    "            action_ = np.random.randint(0,4)\n",
    "        else:\n",
    "            action_ = (np.argmax(qval_))\n",
    "        \n",
    "        action = action_set[action_]\n",
    "        game.makeMove(action)\n",
    "        new_state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/10.0\n",
    "        new_state = Variable(torch.from_numpy(new_state_).float())\n",
    "        reward = game.reward()\n",
    "        \n",
    "        if (len(replay) < buffer): #if buffer not filled, add to it\n",
    "            replay.append((state, action_, reward, new_state))\n",
    "        else: #if buffer full, overwrite old values\n",
    "            replay.pop(0)\n",
    "            replay.append((state, action_, reward, new_state))\n",
    "            #randomly sample our experience replay memory\n",
    "            minibatch = random.sample(replay, batchSize)\n",
    "            X_train = Variable(torch.empty(batchSize, 4, dtype=torch.float))\n",
    "            y_train = Variable(torch.empty(batchSize, 4, dtype=torch.float))\n",
    "            h = 0\n",
    "            for memory in minibatch:\n",
    "                old_state, action_m, reward_m, new_state_m = memory\n",
    "                #old_state = Variable(torch.from_numpy(old_state_).float())\n",
    "                #new_state = Variable(torch.from_numpy(new_state_).float())\n",
    "                old_qval = model2(old_state)\n",
    "                #action = action_set[action_]\n",
    "                newQ = model2(new_state_m).data.numpy()\n",
    "                maxQ = np.max(newQ)\n",
    "                y = torch.zeros((1,4))\n",
    "                y[:] = old_qval[:]\n",
    "                if reward == -1:\n",
    "                    update = (reward_m + (gamma * maxQ))\n",
    "                else:\n",
    "                    update = reward_m\n",
    "                y[0][action_m] = update\n",
    "                X_train[h] = old_qval\n",
    "                y_train[h] = Variable(y)\n",
    "                h+=1\n",
    "                \n",
    "            \n",
    "            #X_train = Variable(torch.from_numpy(np.asarray(X_train)).float())\n",
    "            #y_train = Variable(torch.from_numpy(np.asarray(y_train)).float())\n",
    "            \n",
    "            loss = loss_fn2(X_train, y_train)\n",
    "            print(i, loss.item())\n",
    "            optimizer2.zero_grad()\n",
    "            loss.backward()\n",
    "            losses.append(loss.data[0])\n",
    "            optimizer2.step()\n",
    "            \n",
    "            state = new_state\n",
    "        if reward != -1 or mov > max_moves:\n",
    "            status = 0\n",
    "            mov = 0\n",
    "        clear_output(wait=True)\n",
    "    if epsilon > 0.1:\n",
    "        epsilon -= (1/epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.xlabel(\"Training Steps\")\n",
    "plt.plot(running_mean(losses))\n",
    "#plt.savefig(\"dqn_3_loss_plot.pdf\", format=\"pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testModel(model2, 'random')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test percentage game wins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_games = 1000\n",
    "wins = 0\n",
    "for i in range(max_games):\n",
    "    win = testModel('random', display=False)\n",
    "    if win:\n",
    "        wins += 1\n",
    "win_perc = float(wins) / float(max_games)\n",
    "print(\"Games played: {0}, # of wins: {1}\".format(max_games,wins))\n",
    "print(\"Win percentage: {}\".format(win_perc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With experience replay and target network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "l1 = 64\n",
    "l2 = 164\n",
    "l3 = 150\n",
    "l4 = 4\n",
    "\n",
    "model3 = torch.nn.Sequential(\n",
    "    torch.nn.Linear(l1, l2),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l2, l3),\n",
    "    torch.nn.ReLU(),\n",
    "    torch.nn.Linear(l3,l4),\n",
    ")\n",
    "\n",
    "model3_ = copy.deepcopy(model3) #Target network\n",
    "\n",
    "loss_fn3 = torch.nn.MSELoss(size_average=False)\n",
    "\n",
    "learning_rate3 = 1e-3\n",
    "optimizer3 = torch.optim.Adam(model3.parameters(), lr=learning_rate3)\n",
    "\n",
    "\n",
    "#reinforcement learning specific parameters\n",
    "gamma = 0.9 #since it may take several moves to goal, making gamma high\n",
    "epsilon = 1.0\n",
    "\n",
    "action_set = {\n",
    "    0: 'u',\n",
    "    1: 'd',\n",
    "    2: 'l',\n",
    "    3: 'r',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "# Assume that we are on a CUDA machine, then this should print a CUDA device:\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model3.to(device)\n",
    "model3_.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 700\n",
    "losses = []\n",
    "batchSize = 250\n",
    "buffer = 2000\n",
    "replay = []\n",
    "max_moves = 9\n",
    "c = 500 #target network update step size\n",
    "c_step = 0\n",
    "h = 0\n",
    "for i in range(epochs):\n",
    "    game = Gridworld(size=4, mode='random')\n",
    "    state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/100.0\n",
    "    state = Variable(torch.from_numpy(state_).float()).cuda()\n",
    "    status = 1\n",
    "    mov = 0\n",
    "    #while game still in progress\n",
    "    while(status == 1):\n",
    "        \n",
    "        c_step += 1\n",
    "        if c_step > c:\n",
    "            model3_.load_state_dict(model3.state_dict())\n",
    "            c_step = 0\n",
    "        mov += 1\n",
    "        \n",
    "        qval = model3(state)\n",
    "        qval_ = qval.cpu().data.numpy()\n",
    "        #values, indices = torch.max(tensor, 0)\n",
    "        if (random.random() < epsilon):\n",
    "            action_ = np.random.randint(0,4)\n",
    "        else:\n",
    "            action_ = np.argmax(qval_)\n",
    "            #action_ = torch.argmax(qval_)\n",
    "        action = action_set[action_]\n",
    "        game.makeMove(action)\n",
    "        new_state_ = game.board.render_np().reshape(1,64) + np.random.rand(1,64)/100.0\n",
    "        new_state = Variable(torch.from_numpy(new_state_).float()).cuda()\n",
    "        reward = game.reward()\n",
    "        if mov > max_moves:\n",
    "            reward = -5\n",
    "        if (len(replay) < buffer): #if buffer not filled, add to it\n",
    "            replay.append((state, action_, reward, new_state))\n",
    "        else: #if buffer full, overwrite old values\n",
    "            replay.pop(0)\n",
    "            replay.append((state, action_, reward, new_state))\n",
    "            #randomly sample our experience replay memory\n",
    "            minibatch = random.sample(replay, batchSize)\n",
    "            X_train = Variable(torch.empty(batchSize, 4, dtype=torch.float)).cuda()\n",
    "            y_train = Variable(torch.empty(batchSize, 4, dtype=torch.float)).cuda()\n",
    "            h = 0\n",
    "            for memory in minibatch:\n",
    "                old_state, action_m, reward_m, new_state_m = memory\n",
    "                old_qval = model3(old_state) #TARGET NETWORK!\n",
    "                #newQ = model3_(new_state_m).cpu().data.numpy()\n",
    "                newQ = model3_(new_state_m)\n",
    "                #maxQ = np.max(newQ)\n",
    "                maxQ = torch.max(newQ)\n",
    "                y = torch.zeros((1,4))\n",
    "                y[:] = old_qval[:]\n",
    "                if reward == -1:\n",
    "                    update = (reward_m + (gamma * maxQ))\n",
    "                else:\n",
    "                    update = reward_m\n",
    "                y[0][action_m] = update\n",
    "                X_train[h] = old_qval\n",
    "                y_train[h] = Variable(y)\n",
    "                h+=1\n",
    "            \n",
    "            loss = loss_fn3(X_train, y_train)\n",
    "            print(i, loss.item())\n",
    "            optimizer3.zero_grad()\n",
    "            loss.backward()\n",
    "            losses.append(loss.data[0])\n",
    "            optimizer3.step()\n",
    "            \n",
    "            state = new_state\n",
    "\n",
    "        if reward != -1:\n",
    "            status = 0\n",
    "            mov = 0\n",
    "        clear_output(wait=True)\n",
    "    if epsilon > 0.1:\n",
    "        epsilon -= (1/epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial State:\n",
      "[[' ' '-' ' ' '+']\n",
      " [' ' ' ' 'W' ' ']\n",
      " [' ' ' ' ' ' ' ']\n",
      " [' ' ' ' ' ' 'P']]\n",
      "Move #: 0; Taking action: u\n",
      "[[' ' '-' ' ' '+']\n",
      " [' ' ' ' 'W' ' ']\n",
      " [' ' ' ' ' ' 'P']\n",
      " [' ' ' ' ' ' ' ']]\n",
      "Move #: 1; Taking action: u\n",
      "[[' ' '-' ' ' '+']\n",
      " [' ' ' ' 'W' 'P']\n",
      " [' ' ' ' ' ' ' ']\n",
      " [' ' ' ' ' ' ' ']]\n",
      "Move #: 2; Taking action: u\n",
      "[[' ' '-' ' ' '+']\n",
      " [' ' ' ' 'W' ' ']\n",
      " [' ' ' ' ' ' ' ']\n",
      " [' ' ' ' ' ' ' ']]\n",
      "You won! Reward: 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testModel(model3.to('cpu'), 'random')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Games played: 1000, # of wins: 909\n",
      "Win percentage: 0.909\n"
     ]
    }
   ],
   "source": [
    "test_win_perc(model3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f8bfcfac940>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8bfcfe8a90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.xlabel(\"Training Steps\")\n",
    "plt.plot(running_mean(losses,250))\n",
    "#plt.savefig(\"dqn_3_loss_plot.pdf\", format=\"pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
